
use futures_util::task::SpawnExt;
use tokio::{main, select, task};
use tokio::sync::mpsc;
use tokio::task::{JoinError, spawn};
use tokio::time::{timeout, Duration, sleep};

#[tokio::main]
pub async fn test() {
    // test03().await;
    test_join().await;
}

/* 测试 join */
async fn test_join(){
    let mut join_set = tokio::task::JoinSet::new();
    for i in 1..6 {
        join_set.spawn(async move {
            println!("set {} start", i);
            sleep(Duration::from_secs(i)).await;
            println!("set {} end", i);
            i
        });
    }

    loop {
        let res = join_set.join_next().await;
        match res {
            Some(Ok(r) )=> {
                println!("结果：{:?}", r);
                if r == 4 {
                    break;
                }
            },
            Some(Err(_)) => {
                println!("结果：失败");
            }
            None => {
                println!("结束了。");
                break;
            }
        }
    }

    println!("跳出循环。");

}

async fn test03(){
    let (tx, mut rx) = mpsc::channel(100);
    let tx01 = tx.clone();
    let tasks = vec![
        task::spawn(async move{
            timeout(Duration::from_secs(2), async {
                println!("print 01");
                tokio::time::sleep(std::time::Duration::from_secs(3)).await;
                tx.send(1).await.unwrap();
            }).await.expect("超时处理");
        }),
        task::spawn(async move {
            timeout(Duration::from_secs(2), async {
                println!("print 02");
                tokio::time::sleep(std::time::Duration::from_secs(4)).await;
                tx01.send(2).await.unwrap();
            }).await.expect("超时处理");
        }),
        // 更多任务...
    ];

    while let Some(task_result) = rx.recv().await {
        println!("Task {} has completed.", task_result);
        tasks[1].abort();
        break;
    }

    println!("Task all has completed.");

    // 等待所有任务完成
    // for task in tasks {
    //     task.await.unwrap();
    // }
}
// 循环查询
async fn test02() {
//     let mut result = false;
//     let mut temp = 0;
//     let mut task_list: Vec<_> = (0..5).map(|_| {
//         async {
//             result = false;
//             Ok::<_, std::io::Error>(true)
//         }
//     }).collect();
//
//     let mut time_list = Vec::new();
//     for task in task_list{
//         let ts = timeout(Duration::from_secs(2), task);
//         time_list.push(ts);
//     }
//     let tsld = task_list.get(0).unwrap();
//     loop {
//         select! {
//             _ = tsld => {
// //                 if result {
// //                     break;
// //                 }else{
// //                     temp += 1
// //                     if temp == 5 {
// //                         break;
// //                     }else{
// // // task_list[0] = timeout(Duration::from_secs(2), async{sleep(Duration::from_secs(5).await; Ok(false)})
// //                     }
// //                 }
//             }
//             // _ = &task_list[1] => {
//             //     // if result {
//             //     //     break;
//             //     // }else{
//             //     //     temp += 1
//             //     //     if temp == 5 {
//             //     //         break;
//             //     //     }
//             //     // }
//             // }
//         }
//     }
}

async fn test01() {
    println!("打印信息1。");
    let mut handle_a = spawn(async {
        sleep(Duration::from_secs(2)).await;
        println!("打印信息。");
    });
    let mut handle_b = spawn(async { sleep(Duration::from_secs(1)) });

    select! {
        _ = handle_a => println!("A finished first"),
    }
    select! {  _ = handle_b => println!("B finished first")}

    // let at = timeout(Duration::from_secs(10), handle_a);

    println!("After select!");

    sleep(Duration::from_secs(2)).await;
}
